/*
ont-space - The ontology-based resource metadata repository
Copyright (c) 2006-2008, Information Eng. Research Unit - Univ. of Alcalá
http://www.cc.uah.es/ie
This library is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free
Software Foundation; either version 2.1 of the License, or (at your option)
any later version.
This library is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
details.
You should have received a copy of the GNU Lesser General Public License along
with this library; if not, write to the Free Software Foundation, Inc.,
59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
package org.ontspace.util.translator.sld2owl.owl;

import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import com.hp.hpl.jena.ontology.*;
import com.hp.hpl.jena.rdf.model.RDFNode;
import com.hp.hpl.jena.datatypes.RDFDatatype;
import com.hp.hpl.jena.datatypes.TypeMapper;

import java.util.ArrayList;

public class EnvironmentsTranslator {

    /**
     * Creates a new instance of EnvironmentsTranslator    
     * 
     * @param environments The environment class
     * @param parent The environment parent node of the Dom structure
     * @param ont The ontology
     * @param nsName The namespace
     */
    public EnvironmentsTranslator(OntClass environments, Node parent,
            OntModel ont, Individual instLD, String nsName,
            ArrayList referencesEnvironment) {
        DatatypeProperty identifier =
                ont.getDatatypeProperty(nsName + "identifier");
        DatatypeProperty title =
                ont.getDatatypeProperty(nsName + "title");
        ObjectProperty environmentRef =
                ont.getObjectProperty(nsName + "environment-ref");

        lastInstanceSLDTranslator lastInst =
                new lastInstanceSLDTranslator();

        NodeList learActiChildren =
                parent.getChildNodes();
        if (learActiChildren != null) {
            for (int e =
                    0; e < learActiChildren.getLength(); e++) {
                if (learActiChildren.item(e).getNodeName().compareTo("imsld:environment") ==
                        0) {
                    NodeList enviChildren =
                            learActiChildren.item(e).getChildNodes();
                    try {
                        //create the new instance                    
                        String instance =
                                "environment_instance_" +
                                (String.valueOf(lastInst.lastInstance(environments)));
                        Individual instLe =
                                ont.createIndividual(nsName + instance,
                                environments);
                        instLD.setPropertyValue(environmentRef, instLe);

                        for (int i =
                                0; i < enviChildren.getLength(); i++) {
                            //create and add the attributes to the new instance       
                            if (enviChildren.item(i).getNodeName().compareTo("imsld:title") ==
                                    0) {
                                String leTitle =
                                        enviChildren.item(i).getTextContent();
                                RDFNode titleValue =
                                        ont.createTypedLiteral(enviChildren.item(i).
                                        getTextContent());
                                instLe.setPropertyValue(title, titleValue);

                                NamedNodeMap attrsItem =
                                        learActiChildren.item(e).getAttributes();
                                for (int x =
                                        0; x < attrsItem.getLength(); x++) {
                                    Node attr =
                                            attrsItem.item(x);
                                    if (attr.getNodeName().trim().compareTo("identifier") ==
                                            0) {
                                        TypeMapper tm =
                                                TypeMapper.getInstance();
                                        RDFDatatype overType =
                                                tm.getSafeTypeByName("http://www.w3.org/2001/XMLSchema#ID");
                                        RDFNode identifierValue =
                                                ont.createTypedLiteral(attr.getNodeValue().
                                                trim(), overType);
                                        instLe.setPropertyValue(identifier,
                                                identifierValue);

                                    }
                                }//for                                         
                            }
                            if (enviChildren.item(i).getNodeName().compareTo("imsld:learning-object") ==
                                    0) {
                                LearningObjectTranslator dlo =
                                        new LearningObjectTranslator(enviChildren.item(i),
                                        ont, instLe, nsName);
                            }
                            if (enviChildren.item(i).getNodeName().compareTo("imsld:service") ==
                                    0) {
                                ServicesTranslator ds =
                                        new ServicesTranslator(enviChildren.item(i),
                                        ont, instLe, nsName);
                            }
                            if (enviChildren.item(i).getNodeName().compareTo("imsld:environment-ref") ==
                                    0) {
                                NamedNodeMap attrsref =
                                        enviChildren.item(i).getAttributes();
                                for (int r =
                                        0; r < attrsref.getLength(); r++) {
                                    Node attref =
                                            attrsref.item(r);
                                    if (attref.getNodeName().trim().compareTo("ref") ==
                                            0) {
                                        refTranslator reference =
                                                new refTranslator();
                                        reference.inst =
                                                instLe;
                                        reference.instRef =
                                                attref.getNodeValue().trim();
                                        referencesEnvironment.add(reference);
                                    }

                                }

                            }
                        }//for
                    } catch (Exception ex) {
                        ex.printStackTrace();
                    }
                }//if
            }//for
        }//if

    }
}
